package model;

import java.util.ArrayList;

/**
 *
 * @author Dustin
 */
public class Vertex {
    private String name;
    private int vroegsteTijd;
    private int laatsteTijd;
    private ArrayList<Edge> edges = new ArrayList<Edge>();

    public Vertex(String aName) {
        name = aName;
    }

    public boolean contains(Edge anEdge) {
        boolean contains = false;
        for(int i = 0; i < edges.size() && !contains; i++) {
            if(anEdge.equals(edges.get(i))) {
                contains = true;
            }
        }
        return contains;
    }

    /**
     * Query this Vertex if it has any Edges leading towards it
     * @return true if this Vertex has no Edges leading towards it
     */
    public boolean isStartVertex() {
        boolean isStart = true;
        for(int i = 0; i < edges.size() && isStart; i++) {
            if(edges.get(i).getToVertex().equals(this)) {
                isStart = false;
            }
        }
        return isStart;
    }

    /**
     * Query this Vertex if it has any Edges leading from it
     * @return true if this Vertex has no Edges leading from it
     */
    public boolean isEndVertex() {
        boolean isEnd = true;
        for(int i = 0; i < edges.size() && isEnd; i++) {
            if(edges.get(i).getFromVertex().equals(this)) {
                isEnd = false;
            }
        }
        return isEnd;
    }

    /**
     * Query this Vertex for it's vroegste tijd. If the current vroegste tijd
     * is 0 then the vroegste tijd will be calculated and returned else the
     * calculated vroegste tijd is returned
     * @return
     */
    public int getVroegsteTijd() {
        return vroegsteTijd == 0 ? bepaalVroegsteTijden() : vroegsteTijd;
    }

    /**
     * Query this Vertex for it's laatste tijd. If the current laatste tijd
     * is 0 then the laatste tijd will be calculated and returned else the
     * calculated laatste tijd is returned
     * @return
     */
    public int getLaatsteTijd() {
        return laatsteTijd == 0 ? bepaalLaatsteTijden() : laatsteTijd;
    }

    public ArrayList<Edge> getEdgeList() {
        return edges;
    }

    public Edge getEdge(Vertex vertexTo) {
        Edge edge = null;
        for(int i = 0; i < edges.size() && edge == null; i++) {
            if(vertexTo.equals(edges.get(i).getToVertex())) {
                edge = edges.get(i);
            }
        }
        return edge;
    }

    public String toString() {
        return name + ": " + vroegsteTijd + "," + laatsteTijd;
    }

    public void setVroegsteTijd(int aValue) {
        vroegsteTijd = aValue;
    }

    public void setLaatsteTijd(int aValue) {
        laatsteTijd = aValue;
    }

    public void addEdge(Edge anEdge) {
        if(!contains(anEdge)) {
            edges.add(anEdge);
        }
    }

    public void removeEdge(Edge anEdge) {
        if(!contains(anEdge)) {
            edges.remove(anEdge);
        }
    }

    /**
     * Query this Vertex for it's vroegste tijd.
     * Every Edge connected with this Vertex is checked; if the Edge leads
     * to this Vertex, then a temporary value is calculated and checked if it
     * is less then the current saved vroegste tijd
     * @return
     */
    public int bepaalVroegsteTijden() {
        int startTime = 0;
        for(Edge e : edges) {
            if(e.getFromVertex() != this) {
                int tempTime = e.getFromVertex().getVroegsteTijd() + e.getWeight();
                startTime = tempTime > startTime ? tempTime : startTime;
            }
        }
        setVroegsteTijd(startTime);
        return startTime;
    }

    /**
     * Query this Vertex for it's laatste tijd.
     * Every Edge connected with this Vertex is checked; if the Edge leads
     * from this Vertex, then a temporary value is calculated and checked if it
     * is less then the current saved laatste tijd
     * @return
     */
    public int bepaalLaatsteTijden() {
        int endTime = isEndVertex() ? vroegsteTijd : 0;
        for(Edge e : edges) {
            if(e.getToVertex() != this) {
                int tempTime = e.getToVertex().getLaatsteTijd() - e.getWeight();
                endTime = (endTime == 0 || tempTime < endTime) ? tempTime : endTime;
            }
        }
        
        setLaatsteTijd(isStartVertex() ? 0 : endTime);
        return endTime;
    }
}
